// ----------> GENERATED FILE - DON'T TOUCH! <----------

// generator: ilarkesto.mda.legacy.generator.DaoGenerator










package scrum.server.project;

import java.util.*;
import ilarkesto.core.logging.Log;
import ilarkesto.auth.Auth;
import ilarkesto.base.Cache;
import ilarkesto.persistence.EntityEvent;
import ilarkesto.fp.Predicate;

public abstract class GScenarioDao
            extends ilarkesto.persistence.ADao<Scenario> {

    public final String getEntityName() {
        return Scenario.TYPE;
    }

    public final Class getEntityClass() {
        return Scenario.class;
    }

    public Set<Scenario> getEntitiesVisibleForUser(final scrum.server.admin.User user) {
        return getEntities(new Predicate<Scenario>() {
            public boolean test(Scenario e) {
                return Auth.isVisible(e, user);
            }
        });
    }

    // --- clear caches ---
    public void clearCaches() {
        scenariosByProjectCache.clear();
        projectsCache = null;
        scenariosByNumberCache.clear();
        numbersCache = null;
        scenariosByPointsCache.clear();
        pointssCache = null;
        scenariosByRemainingCache.clear();
        remainingsCache = null;
        scenariosByStateCache.clear();
        statesCache = null;
        scenariosByPriorityCache.clear();
        prioritysCache = null;
        scenariosByCriticismCache.clear();
        criticismsCache = null;
        scenariosByCriticismValueCache.clear();
        criticismValuesCache = null;
        scenariosByPriorityValueCache.clear();
        priorityValuesCache = null;
        scenariosByLabelCache.clear();
        labelsCache = null;
        scenariosByStimulusCache.clear();
        stimulussCache = null;
        scenariosBySourceOfStimulusCache.clear();
        sourceOfStimulussCache = null;
        scenariosByArtifactStimulatedCache.clear();
        artifactStimulatedsCache = null;
        scenariosByEnvironmentCache.clear();
        environmentsCache = null;
        scenariosByResponseCache.clear();
        responsesCache = null;
        scenariosByResponseMeasureCache.clear();
        responseMeasuresCache = null;
        scenariosByQualityCache.clear();
        qualitysCache = null;
        scenariosByStoriesAssociateCache.clear();
        storiesAssociatesCache = null;
    }

    @Override
    public void entityDeleted(EntityEvent event) {
        super.entityDeleted(event);
        if (event.getEntity() instanceof Scenario) {
            clearCaches();
        }
    }

    @Override
    public void entitySaved(EntityEvent event) {
        super.entitySaved(event);
        if (event.getEntity() instanceof Scenario) {
            clearCaches();
        }
    }

    // -----------------------------------------------------------
    // - project
    // -----------------------------------------------------------

    private final Cache<scrum.server.project.Project,Set<Scenario>> scenariosByProjectCache = new Cache<scrum.server.project.Project,Set<Scenario>>(
            new Cache.Factory<scrum.server.project.Project,Set<Scenario>>() {
                public Set<Scenario> create(scrum.server.project.Project project) {
                    return getEntities(new IsProject(project));
                }
            });

    public final Set<Scenario> getScenariosByProject(scrum.server.project.Project project) {
        return new HashSet<Scenario>(scenariosByProjectCache.get(project));
    }
    private Set<scrum.server.project.Project> projectsCache;

    public final Set<scrum.server.project.Project> getProjects() {
        if (projectsCache == null) {
            projectsCache = new HashSet<scrum.server.project.Project>();
            for (Scenario e : getEntities()) {
                if (e.isProjectSet()) projectsCache.add(e.getProject());
            }
        }
        return projectsCache;
    }

    private static class IsProject implements Predicate<Scenario> {

        private scrum.server.project.Project value;

        public IsProject(scrum.server.project.Project value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isProject(value);
        }

    }

    // -----------------------------------------------------------
    // - number
    // -----------------------------------------------------------

    private final Cache<Integer,Set<Scenario>> scenariosByNumberCache = new Cache<Integer,Set<Scenario>>(
            new Cache.Factory<Integer,Set<Scenario>>() {
                public Set<Scenario> create(Integer number) {
                    return getEntities(new IsNumber(number));
                }
            });

    public final Set<Scenario> getScenariosByNumber(int number) {
        return new HashSet<Scenario>(scenariosByNumberCache.get(number));
    }
    private Set<Integer> numbersCache;

    public final Set<Integer> getNumbers() {
        if (numbersCache == null) {
            numbersCache = new HashSet<Integer>();
            for (Scenario e : getEntities()) {
                numbersCache.add(e.getNumber());
            }
        }
        return numbersCache;
    }

    private static class IsNumber implements Predicate<Scenario> {

        private int value;

        public IsNumber(int value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isNumber(value);
        }

    }

    // -----------------------------------------------------------
    // - points
    // -----------------------------------------------------------

    private final Cache<java.lang.Float,Set<Scenario>> scenariosByPointsCache = new Cache<java.lang.Float,Set<Scenario>>(
            new Cache.Factory<java.lang.Float,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.Float points) {
                    return getEntities(new IsPoints(points));
                }
            });

    public final Set<Scenario> getScenariosByPoints(java.lang.Float points) {
        return new HashSet<Scenario>(scenariosByPointsCache.get(points));
    }
    private Set<java.lang.Float> pointssCache;

    public final Set<java.lang.Float> getPointss() {
        if (pointssCache == null) {
            pointssCache = new HashSet<java.lang.Float>();
            for (Scenario e : getEntities()) {
                if (e.isPointsSet()) pointssCache.add(e.getPoints());
            }
        }
        return pointssCache;
    }

    private static class IsPoints implements Predicate<Scenario> {

        private java.lang.Float value;

        public IsPoints(java.lang.Float value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isPoints(value);
        }

    }

    // -----------------------------------------------------------
    // - remaining
    // -----------------------------------------------------------

    private final Cache<java.lang.Float,Set<Scenario>> scenariosByRemainingCache = new Cache<java.lang.Float,Set<Scenario>>(
            new Cache.Factory<java.lang.Float,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.Float remaining) {
                    return getEntities(new IsRemaining(remaining));
                }
            });

    public final Set<Scenario> getScenariosByRemaining(java.lang.Float remaining) {
        return new HashSet<Scenario>(scenariosByRemainingCache.get(remaining));
    }
    private Set<java.lang.Float> remainingsCache;

    public final Set<java.lang.Float> getRemainings() {
        if (remainingsCache == null) {
            remainingsCache = new HashSet<java.lang.Float>();
            for (Scenario e : getEntities()) {
                if (e.isRemainingSet()) remainingsCache.add(e.getRemaining());
            }
        }
        return remainingsCache;
    }

    private static class IsRemaining implements Predicate<Scenario> {

        private java.lang.Float value;

        public IsRemaining(java.lang.Float value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isRemaining(value);
        }

    }

    // -----------------------------------------------------------
    // - state
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByStateCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String state) {
                    return getEntities(new IsState(state));
                }
            });

    public final Set<Scenario> getScenariosByState(java.lang.String state) {
        return new HashSet<Scenario>(scenariosByStateCache.get(state));
    }
    private Set<java.lang.String> statesCache;

    public final Set<java.lang.String> getStates() {
        if (statesCache == null) {
            statesCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isStateSet()) statesCache.add(e.getState());
            }
        }
        return statesCache;
    }

    private static class IsState implements Predicate<Scenario> {

        private java.lang.String value;

        public IsState(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isState(value);
        }

    }

    // -----------------------------------------------------------
    // - priority
    // -----------------------------------------------------------

    private final Cache<Integer,Set<Scenario>> scenariosByPriorityCache = new Cache<Integer,Set<Scenario>>(
            new Cache.Factory<Integer,Set<Scenario>>() {
                public Set<Scenario> create(Integer priority) {
                    return getEntities(new IsPriority(priority));
                }
            });

    public final Set<Scenario> getScenariosByPriority(int priority) {
        return new HashSet<Scenario>(scenariosByPriorityCache.get(priority));
    }
    private Set<Integer> prioritysCache;

    public final Set<Integer> getPrioritys() {
        if (prioritysCache == null) {
            prioritysCache = new HashSet<Integer>();
            for (Scenario e : getEntities()) {
                prioritysCache.add(e.getPriority());
            }
        }
        return prioritysCache;
    }

    private static class IsPriority implements Predicate<Scenario> {

        private int value;

        public IsPriority(int value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isPriority(value);
        }

    }

    // -----------------------------------------------------------
    // - criticism
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByCriticismCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String criticism) {
                    return getEntities(new IsCriticism(criticism));
                }
            });

    public final Set<Scenario> getScenariosByCriticism(java.lang.String criticism) {
        return new HashSet<Scenario>(scenariosByCriticismCache.get(criticism));
    }
    private Set<java.lang.String> criticismsCache;

    public final Set<java.lang.String> getCriticisms() {
        if (criticismsCache == null) {
            criticismsCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isCriticismSet()) criticismsCache.add(e.getCriticism());
            }
        }
        return criticismsCache;
    }

    private static class IsCriticism implements Predicate<Scenario> {

        private java.lang.String value;

        public IsCriticism(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isCriticism(value);
        }

    }

    // -----------------------------------------------------------
    // - criticismValue
    // -----------------------------------------------------------

    private final Cache<Integer,Set<Scenario>> scenariosByCriticismValueCache = new Cache<Integer,Set<Scenario>>(
            new Cache.Factory<Integer,Set<Scenario>>() {
                public Set<Scenario> create(Integer criticismValue) {
                    return getEntities(new IsCriticismValue(criticismValue));
                }
            });

    public final Set<Scenario> getScenariosByCriticismValue(int criticismValue) {
        return new HashSet<Scenario>(scenariosByCriticismValueCache.get(criticismValue));
    }
    private Set<Integer> criticismValuesCache;

    public final Set<Integer> getCriticismValues() {
        if (criticismValuesCache == null) {
            criticismValuesCache = new HashSet<Integer>();
            for (Scenario e : getEntities()) {
                criticismValuesCache.add(e.getCriticismValue());
            }
        }
        return criticismValuesCache;
    }

    private static class IsCriticismValue implements Predicate<Scenario> {

        private int value;

        public IsCriticismValue(int value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isCriticismValue(value);
        }

    }

    // -----------------------------------------------------------
    // - priorityValue
    // -----------------------------------------------------------

    private final Cache<Integer,Set<Scenario>> scenariosByPriorityValueCache = new Cache<Integer,Set<Scenario>>(
            new Cache.Factory<Integer,Set<Scenario>>() {
                public Set<Scenario> create(Integer priorityValue) {
                    return getEntities(new IsPriorityValue(priorityValue));
                }
            });

    public final Set<Scenario> getScenariosByPriorityValue(int priorityValue) {
        return new HashSet<Scenario>(scenariosByPriorityValueCache.get(priorityValue));
    }
    private Set<Integer> priorityValuesCache;

    public final Set<Integer> getPriorityValues() {
        if (priorityValuesCache == null) {
            priorityValuesCache = new HashSet<Integer>();
            for (Scenario e : getEntities()) {
                priorityValuesCache.add(e.getPriorityValue());
            }
        }
        return priorityValuesCache;
    }

    private static class IsPriorityValue implements Predicate<Scenario> {

        private int value;

        public IsPriorityValue(int value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isPriorityValue(value);
        }

    }

    // -----------------------------------------------------------
    // - label
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByLabelCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String label) {
                    return getEntities(new IsLabel(label));
                }
            });

    public final Set<Scenario> getScenariosByLabel(java.lang.String label) {
        return new HashSet<Scenario>(scenariosByLabelCache.get(label));
    }
    private Set<java.lang.String> labelsCache;

    public final Set<java.lang.String> getLabels() {
        if (labelsCache == null) {
            labelsCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isLabelSet()) labelsCache.add(e.getLabel());
            }
        }
        return labelsCache;
    }

    private static class IsLabel implements Predicate<Scenario> {

        private java.lang.String value;

        public IsLabel(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isLabel(value);
        }

    }

    // -----------------------------------------------------------
    // - stimulus
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByStimulusCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String stimulus) {
                    return getEntities(new IsStimulus(stimulus));
                }
            });

    public final Set<Scenario> getScenariosByStimulus(java.lang.String stimulus) {
        return new HashSet<Scenario>(scenariosByStimulusCache.get(stimulus));
    }
    private Set<java.lang.String> stimulussCache;

    public final Set<java.lang.String> getStimuluss() {
        if (stimulussCache == null) {
            stimulussCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isStimulusSet()) stimulussCache.add(e.getStimulus());
            }
        }
        return stimulussCache;
    }

    private static class IsStimulus implements Predicate<Scenario> {

        private java.lang.String value;

        public IsStimulus(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isStimulus(value);
        }

    }

    // -----------------------------------------------------------
    // - sourceOfStimulus
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosBySourceOfStimulusCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String sourceOfStimulus) {
                    return getEntities(new IsSourceOfStimulus(sourceOfStimulus));
                }
            });

    public final Set<Scenario> getScenariosBySourceOfStimulus(java.lang.String sourceOfStimulus) {
        return new HashSet<Scenario>(scenariosBySourceOfStimulusCache.get(sourceOfStimulus));
    }
    private Set<java.lang.String> sourceOfStimulussCache;

    public final Set<java.lang.String> getSourceOfStimuluss() {
        if (sourceOfStimulussCache == null) {
            sourceOfStimulussCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isSourceOfStimulusSet()) sourceOfStimulussCache.add(e.getSourceOfStimulus());
            }
        }
        return sourceOfStimulussCache;
    }

    private static class IsSourceOfStimulus implements Predicate<Scenario> {

        private java.lang.String value;

        public IsSourceOfStimulus(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isSourceOfStimulus(value);
        }

    }

    // -----------------------------------------------------------
    // - artifactStimulated
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByArtifactStimulatedCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String artifactStimulated) {
                    return getEntities(new IsArtifactStimulated(artifactStimulated));
                }
            });

    public final Set<Scenario> getScenariosByArtifactStimulated(java.lang.String artifactStimulated) {
        return new HashSet<Scenario>(scenariosByArtifactStimulatedCache.get(artifactStimulated));
    }
    private Set<java.lang.String> artifactStimulatedsCache;

    public final Set<java.lang.String> getArtifactStimulateds() {
        if (artifactStimulatedsCache == null) {
            artifactStimulatedsCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isArtifactStimulatedSet()) artifactStimulatedsCache.add(e.getArtifactStimulated());
            }
        }
        return artifactStimulatedsCache;
    }

    private static class IsArtifactStimulated implements Predicate<Scenario> {

        private java.lang.String value;

        public IsArtifactStimulated(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isArtifactStimulated(value);
        }

    }

    // -----------------------------------------------------------
    // - environment
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByEnvironmentCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String environment) {
                    return getEntities(new IsEnvironment(environment));
                }
            });

    public final Set<Scenario> getScenariosByEnvironment(java.lang.String environment) {
        return new HashSet<Scenario>(scenariosByEnvironmentCache.get(environment));
    }
    private Set<java.lang.String> environmentsCache;

    public final Set<java.lang.String> getEnvironments() {
        if (environmentsCache == null) {
            environmentsCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isEnvironmentSet()) environmentsCache.add(e.getEnvironment());
            }
        }
        return environmentsCache;
    }

    private static class IsEnvironment implements Predicate<Scenario> {

        private java.lang.String value;

        public IsEnvironment(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isEnvironment(value);
        }

    }

    // -----------------------------------------------------------
    // - response
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByResponseCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String response) {
                    return getEntities(new IsResponse(response));
                }
            });

    public final Set<Scenario> getScenariosByResponse(java.lang.String response) {
        return new HashSet<Scenario>(scenariosByResponseCache.get(response));
    }
    private Set<java.lang.String> responsesCache;

    public final Set<java.lang.String> getResponses() {
        if (responsesCache == null) {
            responsesCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isResponseSet()) responsesCache.add(e.getResponse());
            }
        }
        return responsesCache;
    }

    private static class IsResponse implements Predicate<Scenario> {

        private java.lang.String value;

        public IsResponse(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isResponse(value);
        }

    }

    // -----------------------------------------------------------
    // - responseMeasure
    // -----------------------------------------------------------

    private final Cache<java.lang.String,Set<Scenario>> scenariosByResponseMeasureCache = new Cache<java.lang.String,Set<Scenario>>(
            new Cache.Factory<java.lang.String,Set<Scenario>>() {
                public Set<Scenario> create(java.lang.String responseMeasure) {
                    return getEntities(new IsResponseMeasure(responseMeasure));
                }
            });

    public final Set<Scenario> getScenariosByResponseMeasure(java.lang.String responseMeasure) {
        return new HashSet<Scenario>(scenariosByResponseMeasureCache.get(responseMeasure));
    }
    private Set<java.lang.String> responseMeasuresCache;

    public final Set<java.lang.String> getResponseMeasures() {
        if (responseMeasuresCache == null) {
            responseMeasuresCache = new HashSet<java.lang.String>();
            for (Scenario e : getEntities()) {
                if (e.isResponseMeasureSet()) responseMeasuresCache.add(e.getResponseMeasure());
            }
        }
        return responseMeasuresCache;
    }

    private static class IsResponseMeasure implements Predicate<Scenario> {

        private java.lang.String value;

        public IsResponseMeasure(java.lang.String value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.isResponseMeasure(value);
        }

    }

    // -----------------------------------------------------------
    // - qualitys
    // -----------------------------------------------------------

    private final Cache<scrum.server.project.Quality,Set<Scenario>> scenariosByQualityCache = new Cache<scrum.server.project.Quality,Set<Scenario>>(
            new Cache.Factory<scrum.server.project.Quality,Set<Scenario>>() {
                public Set<Scenario> create(scrum.server.project.Quality quality) {
                    return getEntities(new ContainsQuality(quality));
                }
            });

    public final Set<Scenario> getScenariosByQuality(scrum.server.project.Quality quality) {
        return new HashSet<Scenario>(scenariosByQualityCache.get(quality));
    }
    private Set<scrum.server.project.Quality> qualitysCache;

    public final Set<scrum.server.project.Quality> getQualitys() {
        if (qualitysCache == null) {
            qualitysCache = new HashSet<scrum.server.project.Quality>();
            for (Scenario e : getEntities()) {
                qualitysCache.addAll(e.getQualitys());
            }
        }
        return qualitysCache;
    }

    private static class ContainsQuality implements Predicate<Scenario> {

        private scrum.server.project.Quality value;

        public ContainsQuality(scrum.server.project.Quality value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.containsQuality(value);
        }

    }

    // -----------------------------------------------------------
    // - storiesAssociates
    // -----------------------------------------------------------

    private final Cache<scrum.server.project.Requirement,Set<Scenario>> scenariosByStoriesAssociateCache = new Cache<scrum.server.project.Requirement,Set<Scenario>>(
            new Cache.Factory<scrum.server.project.Requirement,Set<Scenario>>() {
                public Set<Scenario> create(scrum.server.project.Requirement storiesAssociate) {
                    return getEntities(new ContainsStoriesAssociate(storiesAssociate));
                }
            });

    public final Set<Scenario> getScenariosByStoriesAssociate(scrum.server.project.Requirement storiesAssociate) {
        return new HashSet<Scenario>(scenariosByStoriesAssociateCache.get(storiesAssociate));
    }
    private Set<scrum.server.project.Requirement> storiesAssociatesCache;

    public final Set<scrum.server.project.Requirement> getStoriesAssociates() {
        if (storiesAssociatesCache == null) {
            storiesAssociatesCache = new HashSet<scrum.server.project.Requirement>();
            for (Scenario e : getEntities()) {
                storiesAssociatesCache.addAll(e.getStoriesAssociates());
            }
        }
        return storiesAssociatesCache;
    }

    private static class ContainsStoriesAssociate implements Predicate<Scenario> {

        private scrum.server.project.Requirement value;

        public ContainsStoriesAssociate(scrum.server.project.Requirement value) {
            this.value = value;
        }

        public boolean test(Scenario e) {
            return e.containsStoriesAssociate(value);
        }

    }

    // --- valueObject classes ---
    @Override
    protected Set<Class> getValueObjectClasses() {
        Set<Class> ret = new HashSet<Class>(super.getValueObjectClasses());
        return ret;
    }

    @Override
    public Map<String, Class> getAliases() {
        Map<String, Class> aliases = new HashMap<String, Class>(super.getAliases());
        return aliases;
    }

    // --- dependencies ---

    scrum.server.project.ProjectDao projectDao;

    public void setProjectDao(scrum.server.project.ProjectDao projectDao) {
        this.projectDao = projectDao;
    }

    scrum.server.project.QualityDao qualityDao;

    public void setQualityDao(scrum.server.project.QualityDao qualityDao) {
        this.qualityDao = qualityDao;
    }

    scrum.server.project.RequirementDao requirementDao;

    public void setRequirementDao(scrum.server.project.RequirementDao requirementDao) {
        this.requirementDao = requirementDao;
    }

}